/*
    FIGlet.js (a FIGDriver for FIGlet fonts)
    By Patrick Gillespie (patorjk@gmail.com)
    Originally Written For: http://patorjk.com/software/taag/
    License: MIT (with this header staying intact)

    This JavaScript code aims to fully implement the FIGlet spec.
    Full FIGlet spec: http://patorjk.com/software/taag/docs/figfont.txt

    FIGlet fonts are actually kind of complex, which is why you will see
    a lot of code about parsing and interpreting rules. The actual generation
    code is pretty simple and is done near the bottom of the code.
*/

"use strict";

var figlet = figlet || (function() {

  // ---------------------------------------------------------------------
  // Private static variables

  var FULL_WIDTH = 0,
    FITTING = 1,
    SMUSHING = 2,
    CONTROLLED_SMUSHING = 3;

  // ---------------------------------------------------------------------
  // Variable that will hold information about the fonts

  var figFonts = {}; // What stores all of the FIGlet font data
  var figDefaults = {
    font: 'Standard',
    fontPath: './fonts'
  };

  // ---------------------------------------------------------------------
  // Private static methods

  /*
      This method takes in the oldLayout and newLayout data from the FIGfont header file and returns
      the layout information.
  */
  function getSmushingRules(oldLayout, newLayout) {
    var rules = {};
    var val, index, len, code;
    var codes = [[16384,"vLayout",SMUSHING], [8192,"vLayout",FITTING], [4096, "vRule5", true], [2048, "vRule4", true],
      [1024, "vRule3", true], [512, "vRule2", true], [256, "vRule1", true], [128, "hLayout", SMUSHING],
      [64, "hLayout", FITTING], [32, "hRule6", true], [16, "hRule5", true], [8, "hRule4", true], [4, "hRule3", true],
      [2, "hRule2", true], [1, "hRule1", true]];

    val = (newLayout !== null) ? newLayout : oldLayout;
    index = 0;
    len = codes.length;
    while ( index < len ) {
      code = codes[index];
      if (val >= code[0]) {
        val = val - code[0];
        rules[code[1]] = (typeof rules[code[1]] === "undefined") ? code[2] : rules[code[1]];
      } else if (code[1] !== "vLayout" && code[1] !== "hLayout") {
        rules[code[1]] = false;
      }
      index++;
    }

    if (typeof rules["hLayout"] === "undefined") {
      if (oldLayout === 0) {
        rules["hLayout"] = FITTING;
      } else if (oldLayout === -1) {
        rules["hLayout"] = FULL_WIDTH;
      } else {
        if (rules["hRule1"] || rules["hRule2"] || rules["hRule3"] || rules["hRule4"] ||rules["hRule5"] || rules["hRule6"] ) {
          rules["hLayout"] = CONTROLLED_SMUSHING;
        } else {
          rules["hLayout"] = SMUSHING;
        }
      }
    } else if (rules["hLayout"] === SMUSHING) {
      if (rules["hRule1"] || rules["hRule2"] || rules["hRule3"] || rules["hRule4"] ||rules["hRule5"] || rules["hRule6"] ) {
        rules["hLayout"] = CONTROLLED_SMUSHING;
      }
    }

    if (typeof rules["vLayout"] === "undefined") {
      if (rules["vRule1"] || rules["vRule2"] || rules["vRule3"] || rules["vRule4"] ||rules["vRule5"]  ) {
        rules["vLayout"] = CONTROLLED_SMUSHING;
      } else {
        rules["vLayout"] = FULL_WIDTH;
      }
    } else if (rules["vLayout"] === SMUSHING) {
      if (rules["vRule1"] || rules["vRule2"] || rules["vRule3"] || rules["vRule4"] ||rules["vRule5"]  ) {
        rules["vLayout"] = CONTROLLED_SMUSHING;
      }
    }

    return rules;
  }

  /* The [vh]Rule[1-6]_Smush functions return the smushed character OR false if the two characters can't be smushed */

  /*
      Rule 1: EQUAL CHARACTER SMUSHING (code value 1)

          Two sub-characters are smushed into a single sub-character
          if they are the same.  This rule does not smush
          hardblanks.  (See rule 6 on hardblanks below)
  */
  function hRule1_Smush(ch1, ch2, hardBlank) {
    if (ch1 === ch2 && ch1 !== hardBlank) {return ch1;}
    return false;
  }

  /*
      Rule 2: UNDERSCORE SMUSHING (code value 2)

          An underscore ("_") will be replaced by any of: "|", "/",
          "\", "[", "]", "{", "}", "(", ")", "<" or ">".
  */
  function hRule2_Smush(ch1, ch2) {
    var rule2Str = "|/\\[]{}()<>";
    if (ch1 === "_") {
      if (rule2Str.indexOf(ch2) !== -1) {return ch2;}
    } else if (ch2 === "_") {
      if (rule2Str.indexOf(ch1) !== -1) {return ch1;}
    }
    return false;
  }

  /*
      Rule 3: HIERARCHY SMUSHING (code value 4)

          A hierarchy of six classes is used: "|", "/\", "[]", "{}",
          "()", and "<>".  When two smushing sub-characters are
          from different classes, the one from the latter class
          will be used.
  */
  function hRule3_Smush(ch1, ch2) {
    var rule3Classes = "| /\\ [] {} () <>";
    var r3_pos1 = rule3Classes.indexOf(ch1);
    var r3_pos2 = rule3Classes.indexOf(ch2);
    if (r3_pos1 !== -1 && r3_pos2 !== -1) {
      if (r3_pos1 !== r3_pos2 && Math.abs(r3_pos1-r3_pos2) !== 1) {
        return rule3Classes.substr(Math.max(r3_pos1,r3_pos2), 1);
      }
    }
    return false;
  }

  /*
      Rule 4: OPPOSITE PAIR SMUSHING (code value 8)

          Smushes opposing brackets ("[]" or "]["), braces ("{}" or
          "}{") and parentheses ("()" or ")(") together, replacing
          any such pair with a vertical bar ("|").
  */
  function hRule4_Smush(ch1, ch2) {
    var rule4Str = "[] {} ()";
    var r4_pos1 = rule4Str.indexOf(ch1);
    var r4_pos2 = rule4Str.indexOf(ch2);
    if (r4_pos1 !== -1 && r4_pos2 !== -1) {
      if (Math.abs(r4_pos1-r4_pos2) <= 1) {
        return "|";
      }
    }
    return false;
  }

  /*
      Rule 5: BIG X SMUSHING (code value 16)

          Smushes "/\" into "|", "\/" into "Y", and "><" into "X".
          Note that "<>" is not smushed in any way by this rule.
          The name "BIG X" is historical; originally all three pairs
          were smushed into "X".
  */
  function hRule5_Smush(ch1, ch2) {
    var rule5Str = "/\\ \\/ ><";
    var rule5Hash = {"0": "|", "3": "Y", "6": "X"};
    var r5_pos1 = rule5Str.indexOf(ch1);
    var r5_pos2 = rule5Str.indexOf(ch2);
    if (r5_pos1 !== -1 && r5_pos2 !== -1) {
      if ((r5_pos2-r5_pos1) === 1) {
        return rule5Hash[r5_pos1];
      }
    }
    return false;
  }

  /*
      Rule 6: HARDBLANK SMUSHING (code value 32)

          Smushes two hardblanks together, replacing them with a
          single hardblank.  (See "Hardblanks" below.)
  */
  function hRule6_Smush(ch1, ch2, hardBlank) {
    if (ch1 === hardBlank && ch2 === hardBlank) {
      return hardBlank;
    }
    return false;
  }

  /*
      Rule 1: EQUAL CHARACTER SMUSHING (code value 256)

          Same as horizontal smushing rule 1.
  */
  function vRule1_Smush(ch1, ch2) {
    if (ch1 === ch2) {return ch1;}
    return false;
  }

  /*
      Rule 2: UNDERSCORE SMUSHING (code value 512)

          Same as horizontal smushing rule 2.
  */
  function vRule2_Smush(ch1, ch2) {
    var rule2Str = "|/\\[]{}()<>";
    if (ch1 === "_") {
      if (rule2Str.indexOf(ch2) !== -1) {return ch2;}
    } else if (ch2 === "_") {
      if (rule2Str.indexOf(ch1) !== -1) {return ch1;}
    }
    return false;
  }

  /*
      Rule 3: HIERARCHY SMUSHING (code value 1024)

          Same as horizontal smushing rule 3.
  */
  function vRule3_Smush(ch1, ch2) {
    var rule3Classes = "| /\\ [] {} () <>";
    var r3_pos1 = rule3Classes.indexOf(ch1);
    var r3_pos2 = rule3Classes.indexOf(ch2);
    if (r3_pos1 !== -1 && r3_pos2 !== -1) {
      if (r3_pos1 !== r3_pos2 && Math.abs(r3_pos1-r3_pos2) !== 1) {
        return rule3Classes.substr(Math.max(r3_pos1,r3_pos2), 1);
      }
    }
    return false;
  }

  /*
      Rule 4: HORIZONTAL LINE SMUSHING (code value 2048)

          Smushes stacked pairs of "-" and "_", replacing them with
          a single "=" sub-character.  It does not matter which is
          found above the other.  Note that vertical smushing rule 1
          will smush IDENTICAL pairs of horizontal lines, while this
          rule smushes horizontal lines consisting of DIFFERENT
          sub-characters.
  */
  function vRule4_Smush(ch1, ch2) {
    if ( (ch1 === "-" && ch2 === "_") || (ch1 === "_" && ch2 === "-") ) {
      return "=";
    }
    return false;
  }

  /*
      Rule 5: VERTICAL LINE SUPERSMUSHING (code value 4096)

          This one rule is different from all others, in that it
          "supersmushes" vertical lines consisting of several
          vertical bars ("|").  This creates the illusion that
          FIGcharacters have slid vertically against each other.
          Supersmushing continues until any sub-characters other
          than "|" would have to be smushed.  Supersmushing can
          produce impressive results, but it is seldom possible,
          since other sub-characters would usually have to be
          considered for smushing as soon as any such stacked
          vertical lines are encountered.
  */
  function vRule5_Smush(ch1, ch2) {
    if ( ch1 === "|" && ch2 === "|" ) {
      return "|";
    }
    return false;
  }

  /*
      Universal smushing simply overrides the sub-character from the
      earlier FIGcharacter with the sub-character from the later
      FIGcharacter.  This produces an "overlapping" effect with some
      FIGfonts, wherin the latter FIGcharacter may appear to be "in
      front".
  */
  function uni_Smush(ch1, ch2, hardBlank) {
    if (ch2 === " " || ch2 === "") {
      return ch1;
    } else if (ch2 === hardBlank && ch1 !== " ") {
      return ch1;
    } else {
      return ch2;
    }
  }

  // --------------------------------------------------------------------------
  // main vertical smush routines (excluding rules)

  /*
      txt1 - A line of text
      txt2 - A line of text
      opts - FIGlet options array

      About: Takes in two lines of text and returns one of the following:
      "valid" - These lines can be smushed together given the current smushing rules
      "end" - The lines can be smushed, but we're at a stopping point
      "invalid" - The two lines cannot be smushed together
  */
  function canVerticalSmush(txt1, txt2, opts) {
    if (opts.fittingRules.vLayout === FULL_WIDTH) {return "invalid";}
    var ii, len = Math.min(txt1.length, txt2.length);
    var ch1, ch2, endSmush = false, validSmush;
    if (len===0) {return "invalid";}

    for (ii = 0; ii < len; ii++) {
      ch1 = txt1.substr(ii,1);
      ch2 = txt2.substr(ii,1);
      if (ch1 !== " " && ch2 !== " ") {
        if (opts.fittingRules.vLayout === FITTING) {
          return "invalid";
        } else if (opts.fittingRules.vLayout === SMUSHING) {
          return "end";
        } else {
          if (vRule5_Smush(ch1,ch2)) {endSmush = endSmush || false; continue;} // rule 5 allow for "super" smushing, but only if we're not already ending this smush
          validSmush = false;
          validSmush = (opts.fittingRules.vRule1) ? vRule1_Smush(ch1,ch2) : validSmush;
          validSmush = (!validSmush && opts.fittingRules.vRule2) ? vRule2_Smush(ch1,ch2) : validSmush;
          validSmush = (!validSmush && opts.fittingRules.vRule3) ? vRule3_Smush(ch1,ch2) : validSmush;
          validSmush = (!validSmush && opts.fittingRules.vRule4) ? vRule4_Smush(ch1,ch2) : validSmush;
          endSmush = true;
          if (!validSmush) {return "invalid";}
        }
      }
    }
    if (endSmush) {
      return "end";
    } else {
      return "valid";
    }
  }

  function getVerticalSmushDist(lines1, lines2, opts) {
    var maxDist = lines1.length;
    var len1 = lines1.length;
    var len2 = lines2.length;
    var subLines1, subLines2, slen;
    var curDist = 1;
    var ii, ret, result;
    while (curDist <= maxDist) {

      subLines1 = lines1.slice(Math.max(0,len1-curDist), len1);
      subLines2 = lines2.slice(0, Math.min(maxDist, curDist));

      slen = subLines2.length;//TODO:check this
      result = "";
      for (ii = 0; ii < slen; ii++) {
        ret = canVerticalSmush(subLines1[ii], subLines2[ii], opts);
        if (ret === "end") {
          result = ret;
        } else if (ret === "invalid") {
          result = ret;
          break;
        } else {
          if (result === "") {
            result = "valid";
          }
        }
      }

      if (result === "invalid") {curDist--;break;}
      if (result === "end") {break;}
      if (result === "valid") {curDist++;}
    }

    return Math.min(maxDist,curDist);
  }

  function verticallySmushLines(line1, line2, opts) {
    var ii, len = Math.min(line1.length, line2.length);
    var ch1, ch2, result = "", validSmush;

    for (ii = 0; ii < len; ii++) {
      ch1 = line1.substr(ii,1);
      ch2 = line2.substr(ii,1);
      if (ch1 !== " " && ch2 !== " ") {
        if (opts.fittingRules.vLayout === FITTING) {
          result += uni_Smush(ch1,ch2);
        } else if (opts.fittingRules.vLayout === SMUSHING) {
          result += uni_Smush(ch1,ch2);
        } else {
          validSmush = (opts.fittingRules.vRule5) ? vRule5_Smush(ch1,ch2) : validSmush;
          validSmush = (!validSmush && opts.fittingRules.vRule1) ? vRule1_Smush(ch1,ch2) : validSmush;
          validSmush = (!validSmush && opts.fittingRules.vRule2) ? vRule2_Smush(ch1,ch2) : validSmush;
          validSmush = (!validSmush && opts.fittingRules.vRule3) ? vRule3_Smush(ch1,ch2) : validSmush;
          validSmush = (!validSmush && opts.fittingRules.vRule4) ? vRule4_Smush(ch1,ch2) : validSmush;
          result += validSmush;
        }
      } else {
        result += uni_Smush(ch1,ch2);
      }
    }
    return result;
  }

  function verticalSmush(lines1, lines2, overlap, opts) {
    var len1 = lines1.length;
    var len2 = lines2.length;
    var piece1 = lines1.slice(0, Math.max(0,len1-overlap));
    var piece2_1 = lines1.slice(Math.max(0,len1-overlap), len1);
    var piece2_2 = lines2.slice(0, Math.min(overlap, len2));
    var ii, len, line, piece2 = [], piece3, result = [];

    len = piece2_1.length;
    for (ii = 0; ii < len; ii++) {
      if (ii >= len2) {
        line = piece2_1[ii];
      } else {
        line = verticallySmushLines(piece2_1[ii], piece2_2[ii], opts);
      }
      piece2.push(line);
    }

    piece3 = lines2.slice(Math.min(overlap,len2), len2);

    return result.concat(piece1,piece2,piece3);
  }

  function padLines(lines, numSpaces) {
    var ii, len = lines.length, padding = "";
    for (ii = 0; ii < numSpaces; ii++) {
      padding += " ";
    }
    for (ii = 0; ii < len; ii++) {
      lines[ii] += padding;
    }
  }

  function smushVerticalFigLines(output, lines, opts) {
    var len1 = output[0].length;
    var len2 = lines[0].length;
    var overlap;
    if (len1 > len2) {
      padLines(lines, len1-len2);
    } else if (len2 > len1) {
      padLines(output, len2-len1);
    }
    overlap = getVerticalSmushDist(output, lines, opts);
    return verticalSmush(output, lines, overlap,opts);
  }

  // -------------------------------------------------------------------------
  // Main horizontal smush routines (excluding rules)

  function getHorizontalSmushLength(txt1, txt2, opts) {
    if (opts.fittingRules.hLayout === FULL_WIDTH) {return 0;}
    var ii, len1 = txt1.length, len2 = txt2.length;
    var maxDist = len1;
    var curDist = 1;
    var breakAfter = false;
    var validSmush = false;
    var seg1, seg2, ch1, ch2;
    if (len1 === 0) {return 0;}

    distCal: while (curDist <= maxDist) {
      seg1 = txt1.substr(len1-curDist,curDist);
      seg2 = txt2.substr(0,Math.min(curDist,len2));
      for (ii = 0; ii < Math.min(curDist,len2); ii++) {
        ch1 = seg1.substr(ii,1);
        ch2 = seg2.substr(ii,1);
        if (ch1 !== " " && ch2 !== " " ) {
          if (opts.fittingRules.hLayout === FITTING) {
            curDist = curDist - 1;
            break distCal;
          } else if (opts.fittingRules.hLayout === SMUSHING) {
            if (ch1 === opts.hardBlank || ch2 === opts.hardBlank) {
              curDist = curDist - 1; // universal smushing does not smush hardblanks
            }
            break distCal;
          } else {
            breakAfter = true; // we know we need to break, but we need to check if our smushing rules will allow us to smush the overlapped characters
            validSmush = false; // the below checks will let us know if we can smush these characters

            validSmush = (opts.fittingRules.hRule1) ? hRule1_Smush(ch1,ch2,opts.hardBlank) : validSmush;
            validSmush = (!validSmush && opts.fittingRules.hRule2) ? hRule2_Smush(ch1,ch2,opts.hardBlank) : validSmush;
            validSmush = (!validSmush && opts.fittingRules.hRule3) ? hRule3_Smush(ch1,ch2,opts.hardBlank) : validSmush;
            validSmush = (!validSmush && opts.fittingRules.hRule4) ? hRule4_Smush(ch1,ch2,opts.hardBlank) : validSmush;
            validSmush = (!validSmush && opts.fittingRules.hRule5) ? hRule5_Smush(ch1,ch2,opts.hardBlank) : validSmush;
            validSmush = (!validSmush && opts.fittingRules.hRule6) ? hRule6_Smush(ch1,ch2,opts.hardBlank) : validSmush;

            if (!validSmush) {
              curDist = curDist - 1;
              break distCal;
            }
          }
        }
      }
      if (breakAfter) {break;}
      curDist++;
    }
    return Math.min(maxDist,curDist);
  }

  function horizontalSmush(textBlock1, textBlock2, overlap, opts) {
    var ii, jj, ch, outputFig = [],
      overlapStart,piece1,piece2,piece3,len1,len2,txt1,txt2;

    for (ii = 0; ii < opts.height; ii++) {
      txt1 = textBlock1[ii];
      txt2 = textBlock2[ii];
      len1 = txt1.length;
      len2 = txt2.length;
      overlapStart = len1-overlap;
      piece1 = txt1.substr(0,Math.max(0,overlapStart));
      piece2 = "";

      // determine overlap piece
      var seg1 = txt1.substr(Math.max(0,len1-overlap),overlap);
      var seg2 = txt2.substr(0,Math.min(overlap,len2));

      for (jj = 0; jj < overlap; jj++) {
        var ch1 = (jj < len1) ? seg1.substr(jj,1) : " ";
        var ch2 = (jj < len2) ? seg2.substr(jj,1) : " ";

        if (ch1 !== " " && ch2 !== " ") {
          if (opts.fittingRules.hLayout === FITTING) {
            piece2 += uni_Smush(ch1, ch2, opts.hardBlank);
          } else if (opts.fittingRules.hLayout === SMUSHING) {
            piece2 += uni_Smush(ch1, ch2, opts.hardBlank);
          } else {
            // Controlled Smushing
            var nextCh = "";
            nextCh = (!nextCh && opts.fittingRules.hRule1) ? hRule1_Smush(ch1,ch2,opts.hardBlank) : nextCh;
            nextCh = (!nextCh && opts.fittingRules.hRule2) ? hRule2_Smush(ch1,ch2,opts.hardBlank) : nextCh;
            nextCh = (!nextCh && opts.fittingRules.hRule3) ? hRule3_Smush(ch1,ch2,opts.hardBlank) : nextCh;
            nextCh = (!nextCh && opts.fittingRules.hRule4) ? hRule4_Smush(ch1,ch2,opts.hardBlank) : nextCh;
            nextCh = (!nextCh && opts.fittingRules.hRule5) ? hRule5_Smush(ch1,ch2,opts.hardBlank) : nextCh;
            nextCh = (!nextCh && opts.fittingRules.hRule6) ? hRule6_Smush(ch1,ch2,opts.hardBlank) : nextCh;
            nextCh = nextCh || uni_Smush(ch1, ch2, opts.hardBlank);
            piece2 += nextCh;
          }
        } else {
          piece2 += uni_Smush(ch1, ch2, opts.hardBlank);
        }
      }

      if (overlap >= len2) {
        piece3 = "";
      } else {
        piece3 = txt2.substr(overlap,Math.max(0,len2-overlap));
      }
      outputFig[ii] = piece1 + piece2 + piece3;
    }
    return outputFig;
  }

  function generateFigTextLine(txt, figChars, opts) {
    var charIndex, figChar, overlap = 0, row, outputFigText = [], len=opts.height;
    for (row = 0; row < len; row++) {
      outputFigText[row] = "";
    }
    if (opts.printDirection === 1) {
      txt = txt.split('').reverse().join('');
    }
    len=txt.length;
    for (charIndex = 0; charIndex < len; charIndex++) {
      figChar = figChars[txt.substr(charIndex,1).charCodeAt(0)];
      if (figChar) {
        if (opts.fittingRules.hLayout !== FULL_WIDTH) {
          overlap = 10000;// a value too high to be the overlap
          for (row = 0; row < opts.height; row++) {
            overlap = Math.min(overlap, getHorizontalSmushLength(outputFigText[row], figChar[row], opts));
          }
          overlap = (overlap === 10000) ? 0 : overlap;
        }
        outputFigText = horizontalSmush(outputFigText, figChar, overlap, opts);
      }
    }
    // remove hardblanks
    if (opts.showHardBlanks !== true) {
      len = outputFigText.length;
      for (row = 0; row < len; row++) {
        outputFigText[row] = outputFigText[row].replace(new RegExp("\\"+opts.hardBlank,"g")," ");
      }
    }
    return outputFigText;
  }

  // -------------------------------------------------------------------------
  // Parsing and Generation methods

  var getHorizontalFittingRules = function(layout, options) {
    var props = ["hLayout", "hRule1","hRule2","hRule3","hRule4","hRule5","hRule6"],
      params = {}, prop, ii;
    if (layout === "default") {
      for (ii = 0; ii < props.length; ii++) {
        params[props[ii]] = options.fittingRules[props[ii]];
      }
    } else if (layout === "full") {
      params = {"hLayout": FULL_WIDTH,"hRule1":false,"hRule2":false,"hRule3":false,"hRule4":false,"hRule5":false,"hRule6":false};
    } else if (layout === "fitted") {
      params = {"hLayout": FITTING,"hRule1":false,"hRule2":false,"hRule3":false,"hRule4":false,"hRule5":false,"hRule6":false};
    } else if (layout === "controlled smushing") {
      params = {"hLayout": CONTROLLED_SMUSHING,"hRule1":true,"hRule2":true,"hRule3":true,"hRule4":true,"hRule5":true,"hRule6":true};
    } else if (layout === "universal smushing") {
      params = {"hLayout": SMUSHING,"hRule1":false,"hRule2":false,"hRule3":false,"hRule4":false,"hRule5":false,"hRule6":false};
    } else {
      return;
    }
    return params;
  };

  var getVerticalFittingRules = function(layout, options) {
    var props = ["vLayout", "vRule1","vRule2","vRule3","vRule4","vRule5"],
      params = {}, prop, ii;
    if (layout === "default") {
      for (ii = 0; ii < props.length; ii++) {
        params[props[ii]] = options.fittingRules[props[ii]];
      }
    } else if (layout === "full") {
      params = {"vLayout": FULL_WIDTH,"vRule1":false,"vRule2":false,"vRule3":false,"vRule4":false,"vRule5":false};
    } else if (layout === "fitted") {
      params = {"vLayout": FITTING,"vRule1":false,"vRule2":false,"vRule3":false,"vRule4":false,"vRule5":false};
    } else if (layout === "controlled smushing") {
      params = {"vLayout": CONTROLLED_SMUSHING,"vRule1":true,"vRule2":true,"vRule3":true,"vRule4":true,"vRule5":true};
    } else if (layout === "universal smushing") {
      params = {"vLayout": SMUSHING,"vRule1":false,"vRule2":false,"vRule3":false,"vRule4":false,"vRule5":false};
    } else {
      return;
    }
    return params;
  };

  /*
      Generates the ASCII Art
      - fontName: Font to use
      - option: Options to override the defaults
      - txt: The text to make into ASCII Art
  */
  var generateText = function(fontName, options, txt) {
    txt = txt.replace(/\r\n/g,"\n").replace(/\r/g,"\n");
    var lines = txt.split("\n");
    var figLines = [];
    var ii, len, output;
    len = lines.length;
    for (ii = 0; ii < len; ii++) {
      figLines.push( generateFigTextLine(lines[ii], figFonts[fontName], options) );
    }
    len = figLines.length;
    output = figLines[0];
    for (ii = 1; ii < len; ii++) {
      output = smushVerticalFigLines(output, figLines[ii], options);
    }

    return output.join("\n");
  };

  // -------------------------------------------------------------------------
  // Public methods

  /*
      A short-cut for the figlet.text method

      Parameters:
      - txt (string): The text to make into ASCII Art
      - options (object/string - optional): Options that will override the current font's default options.
        If a string is provided instead of an object, it is assumed to be the font name.

          * font
          * horizontalLayout
          * verticalLayout
          * showHardBlanks - Wont remove hardblank characters

      - next (function): A callback function, it will contained the outputted ASCII Art.
  */
  var me = function(txt, options, next) {
    me.text(txt, options, next);
  };
  me.text = function(txt, options, next) {
    var fontName = '';

    // Validate inputs
    txt = txt + '';

    if (typeof arguments[1] === 'function') {
      next = options;
      options = {};
      options.font = figDefaults.font; // default font
    }

    if (typeof options === 'string') {
      fontName = options;
      options = {};
    } else {
      options = options || {};
      fontName = options.font || figDefaults.font;
    }

    /*
        Load the font. If it loads, it's data will be contained in the figFonts object.
        The callback will recieve a fontsOpts object, which contains the default
        options of the font (its fitting rules, etc etc).
    */
    me.loadFont(fontName, function(err, fontOpts) {
      if (err) {
        return next(err);
      }

      next(null, generateText(fontName, _reworkFontOpts(fontOpts, options), txt));
    });
  };

  /*
      Synchronous version of figlet.text.
      Accepts the same parameters.
   */
  me.textSync = function(txt, options) {
    var fontName = '';

    // Validate inputs
    txt = txt + '';

    if (typeof options === 'string') {
      fontName = options;
      options = {};
    } else {
      options = options || {};
      fontName = options.font || figDefaults.font;
    }

    var fontOpts = _reworkFontOpts(me.loadFontSync(fontName), options);
    return generateText(fontName, fontOpts, txt);
  };

  /*
    takes assigned options and merges them with the default options from the choosen font
   */
  function _reworkFontOpts(fontOpts, options) {
    var myOpts = JSON.parse(JSON.stringify(fontOpts)), // make a copy because we may edit this (see below)
      params,
      prop;

    /*
     If the user is chosing to use a specific type of layout (e.g., 'full', 'fitted', etc etc)
     Then we need to override the default font options.
     */
    if (typeof options.horizontalLayout !== 'undefined') {
      params = getHorizontalFittingRules(options.horizontalLayout, fontOpts);
      for (prop in params) {
        myOpts.fittingRules[prop] = params[prop];
      }
    }
    if (typeof options.verticalLayout !== 'undefined') {
      params = getVerticalFittingRules(options.verticalLayout, fontOpts);
      for (prop in params) {
        myOpts.fittingRules[prop] = params[prop];
      }
    }
    myOpts.printDirection = (typeof options.printDirection !== 'undefined') ? options.printDirection : fontOpts.printDirection;
    myOpts.showHardBlanks = options.showHardBlanks || false;

    return myOpts;
  }

  /*
      Returns metadata about a specfic FIGlet font.

      Returns:
          next(err, options, headerComment)
          - err: The error if an error occurred, otherwise null/falsey.
          - options (object): The options defined for the font.
          - headerComment (string): The font's header comment.
  */
  me.metadata = function(fontName, next) {
    fontName = fontName + '';

    /*
        Load the font. If it loads, it's data will be contained in the figFonts object.
        The callback will recieve a fontsOpts object, which contains the default
        options of the font (its fitting rules, etc etc).
    */
    me.loadFont(fontName, function(err, fontOpts) {
      if (err) {
        next(err);
        return;
      }

      next(null, fontOpts, figFonts[fontName].comment);
    });
  };

  /*
      Allows you to override defaults. See the definition of the figDefaults object up above
      to see what properties can be overridden.
      Returns the options for the font.
  */
  me.defaults = function(opts) {
    if (typeof opts === 'object' && opts !== null) {
      for (var prop in opts) {
        if (opts.hasOwnProperty(prop)) {
          figDefaults[prop] = opts[prop];
        }
      }
    }
    return JSON.parse(JSON.stringify(figDefaults));
  };

  /*
      Parses data from a FIGlet font file and places it into the figFonts object.
  */
  me.parseFont = function(fontName, data) {
    data = data.replace(/\r\n/g,"\n").replace(/\r/g,"\n");
    figFonts[fontName] = {};

    var lines = data.split("\n");
    var headerData = lines.splice(0,1)[0].split(" ");
    var figFont = figFonts[fontName];
    var opts = {};

    opts.hardBlank = headerData[0].substr(5,1);
    opts.height = parseInt(headerData[1], 10);
    opts.baseline = parseInt(headerData[2], 10);
    opts.maxLength = parseInt(headerData[3], 10);
    opts.oldLayout = parseInt(headerData[4], 10);
    opts.numCommentLines = parseInt(headerData[5], 10);
    opts.printDirection = (headerData.length >= 6) ? parseInt(headerData[6], 10) : 0;
    opts.fullLayout = (headerData.length >= 7) ? parseInt(headerData[7], 10) : null;
    opts.codeTagCount = (headerData.length >= 8) ? parseInt(headerData[8], 10) : null;
    opts.fittingRules = getSmushingRules(opts.oldLayout, opts.fullLayout);

    figFont.options = opts;

    // error check
    if (opts.hardBlank.length !== 1 ||
      isNaN(opts.height) ||
      isNaN(opts.baseline) ||
      isNaN(opts.maxLength) ||
      isNaN(opts.oldLayout) ||
      isNaN(opts.numCommentLines) )
    {
      throw new Error('FIGlet header contains invalid values.');
    }

    /*
        All FIGlet fonts must contain chars 32-126, 196, 214, 220, 228, 246, 252, 223
    */

    var charNums = [], ii;
    for (ii = 32; ii <= 126; ii++) {
      charNums.push(ii);
    }
    charNums = charNums.concat(196, 214, 220, 228, 246, 252, 223);

    // error check - validate that there are enough lines in the file
    if (lines.length < (opts.numCommentLines + (opts.height * charNums.length)) ) {
      throw new Error('FIGlet file is missing data.');
    }

    /*
        Parse out the context of the file and put it into our figFont object
    */

    var cNum, endCharRegEx, parseError = false;

    figFont.comment = lines.splice(0,opts.numCommentLines).join("\n");
    figFont.numChars = 0;

    while (lines.length > 0 && figFont.numChars < charNums.length) {
      cNum = charNums[figFont.numChars];
      figFont[cNum] = lines.splice(0,opts.height);
      // remove end sub-chars
      for (ii = 0; ii < opts.height; ii++) {
        if (typeof figFont[cNum][ii] === "undefined") {
          figFont[cNum][ii] = "";
        } else {
          endCharRegEx = new RegExp("\\"+figFont[cNum][ii].substr(figFont[cNum][ii].length-1,1)+"+$");
          figFont[cNum][ii] = figFont[cNum][ii].replace(endCharRegEx,"");
        }
      }
      figFont.numChars++;
    }

    /*
        Now we check to see if any additional characters are present
    */

    while (lines.length > 0) {
      cNum = lines.splice(0,1)[0].split(" ")[0];
      if ( /^0[xX][0-9a-fA-F]+$/.test(cNum) ) {
        cNum = parseInt(cNum, 16);
      } else if ( /^0[0-7]+$/.test(cNum) ) {
        cNum = parseInt(cNum, 8);
      } else if ( /^[0-9]+$/.test(cNum) ) {
        cNum = parseInt(cNum, 10);
      } else if ( /^-0[xX][0-9a-fA-F]+$/.test(cNum) ) {
        cNum = parseInt(cNum, 16);
      } else {
        if (cNum === "") {break;}
        // something's wrong
        console.log("Invalid data:"+cNum);
        parseError = true;
        break;
      }

      figFont[cNum] = lines.splice(0,opts.height);
      // remove end sub-chars
      for (ii = 0; ii < opts.height; ii++) {
        if (typeof figFont[cNum][ii] === "undefined") {
          figFont[cNum][ii] = "";
        } else {
          endCharRegEx = new RegExp("\\"+figFont[cNum][ii].substr(figFont[cNum][ii].length-1,1)+"+$");
          figFont[cNum][ii] = figFont[cNum][ii].replace(endCharRegEx,"");
        }
      }
      figFont.numChars++;
    }

    // error check
    if (parseError === true) {
      throw new Error('Error parsing data.');
    }

    return opts;
  };

  /*
      Loads a font.
  */
  me.loadFont = function(fontName, next) {
    if (figFonts[fontName]) {
      next(null, figFonts[fontName].options);
      return;
    }

    if (typeof fetch !== 'function') {
      console.error('figlet.js requires the fetch API or a fetch polyfill such as https://cdnjs.com/libraries/fetch');
      throw new Error('fetch is required for figlet.js to work.')
    }

    fetch(figDefaults.fontPath + '/' + fontName + '.flf')
      .then(function(response) {
        if(response.ok) {
          return response.text();
        }

        console.log('Unexpected response', response);
        throw new Error('Network response was not ok.');
      })
      .then(function(text) {
        next(null, me.parseFont(fontName, text));
      })
      .catch(next);
  };

  /*
      loads a font synchronously, not implemented for the browser
   */
  me.loadFontSync = function(name) {
    if (figFonts[name]) {
      return figFonts[name].options;
    }
    throw new Error('synchronous font loading is not implemented for the browser');
  };

  /*
      preloads a list of fonts prior to using textSync
      - fonts: an array of font names (i.e. ["Standard","Soft"])
      - next: callback function
   */
  me.preloadFonts = function(fonts, next) {

    if (typeof jQuery === 'undefined') { /* TODO: create common function for jQuery checks */
      throw new Error('jQuery is required for ajax method to work.');
    }

    jQuery.when.apply(this, fonts.map(function(name){
      return jQuery.get(figDefaults.fontPath + '/' + name + '.flf')
    })).then(function() {
      var args = fonts.length > 1 ? arguments : [arguments];
      for(var i in fonts){
        me.parseFont(fonts[i], args[i][0]);
      }
      if(next)next();
    });
  };

  me.figFonts = figFonts;

  return me;
})();

// for node.js
if (typeof module !== 'undefined') {
  if (typeof module.exports !== 'undefined') {
    module.exports = figlet;
  }
}
